In a rendering technique known as ray casting, a computer simulates the casting of rays onto a virtual scene, and renders the scene in accordance with the interaction between these rays and objects in the scene.
In some rendering applications, objects in the virtual scene are modeled as quadratic surfaces, or “quadrics.” The equation for a quadric may be expressed in homogenous (x,y,z,w) coordinates as Ax2+2Bxy+2Cxz+2Dxw+Ey2+2Fyz+2Gyw+Hz2+2Izw+Jw2=0. More compactly, this may be written in matrix form as XTQX=0, where
  X  =                                          x                                                y                                                z                                                w                              ⁢                          ⁢      and      ⁢                          ⁢      Q        =                                        A                                B                                C                                D                                                B                                E                                F                                G                                                C                                F                                H                                I                                                D                                G                                I                                J                              .      (Generally, w is set to 1.) Examples of quadric surfaces include spheres, ellipsoids, cylinders, cones, hyperbolic paraboloids, paraboloids, and hyperboloids.
A ray may be expressed by the equation R=O+tD, where R is any point on the ray, O is the origin of the ray, D is the direction vector of the ray, and t is a scalar parameter. R, O, and D may be expressed in homogenous coordinates.
Sigg, Christian, et al., “GPU-Based Ray-Casting of Quadratic Surfaces,” SPBG, 2006, which is incorporated herein by reference, proposes an efficient rendering technique for quadric primitives based on GPU-accelerated splatting.